Easy2Siksha.com
GNDU Queson Paper 2024
Bachelor of Computer Applicaon (BCA)
3rd Semester
DATABASE MANAGEMENT SYSTEM
Time Allowed-3 Hours Maximum Marks-100
Note:- Aempt FIVE quesons in all, selecng at least ONE queson from each secon.
The h queson may be aempted from any secon. All quesons carry equal marks.
SECTION-A
1. What are the dierent types of data models supported by database system? What is the
dierence between Hierarchical Model and Network Model? Explain in detail.
2. Explain the following concepts giving suitable example of E-R Diagram:
(a)Strong Enty.
(b)Weak Enty
(c) Relaonships
(d) Specializaon
(c) (Generalizaon.
SECTION-B
3. Explain Normalizaon Explain the concept of mul-valued dependency with an
example. How would you remove it to achieve 4NF?
Easy2Siksha.com
4(a) Explain the signicance of the DBTG report in the development of database
management systems
(b) Describe the principle of least privilege and its importance in database security.
SECTIONC
5. (a) Explain the concept of DCL. Explain the use of DCL. statements using suitable
examples.
(b) Explain the use of Union, Intersecon and Minus funcon using suitable example.
6. What is a cursor in a database, and why is it used How would you use the % FOUND,
%NOTFOUND. %ROWCOUNT, and %ISOPEN aributes in a SQL block? 20
SECTION-D
7. How does big data dier from tradional data processing systems? Write some popular
tools used in big data analycs. Provide examples of how big data analycs is 1 used in
dierent industries.
8. What are NoSQL databases? How does NoSQL dier from tradional relaonal
databases? Explain some advantages of NoSQL databases.
Easy2Siksha.com
GNDU Answer Paper 2024
Bachelor of Computer Applicaon (BCA)
3rd Semester
DATABASE MANAGEMENT SYSTEM
Time Allowed-3 Hours Maximum Marks-100
Note:- Aempt FIVE quesons in all, selecng at least ONE queson from each secon.
The h queson may be aempted from any secon. All quesons carry equal marks.
SECTION-A
1. What are the dierent types of data models supported by database system? What is the
dierence between Hierarchical Model and Network Model? Explain in detail.
Ans: Imagine you’ve just walked into a giant library. This library isn’t like your usual one—
it’s magical. Instead of books stacked on shelves, this library organizes information in
different styles of storytelling. Some shelves are arranged in a strict family tree, some look
like a web of interconnected paths, some behave like tables of rows and columns, while
others allow you to simply say what you want and they’ll fetch it magically.
This magical library is nothing but a Database System, and these different storytelling styles
are what we call Data Models.
Data models are nothing but ways to represent and organize data inside a database. Just
like a librarian needs rules to arrange books—alphabetical, by subject, or by author—the
database also needs rules to arrange data so it can be stored, searched, and updated easily.
Now, let’s slowly unpack this story and understand the types of data models one by one.
Types of Data Models in Database Systems
There are several types of data models, but they can be broadly classified into three major
categories:
Easy2Siksha.com
1. Conceptual Data Models
Think of this as a blueprint of a building. Before constructing a house, an architect creates a
design showing where rooms, doors, and windows will be. Similarly, conceptual data models
are high-level designs that explain what data will be stored, how entities are related, but
without worrying about the technical implementation.
• Example: The Entity-Relationship (ER) model, which uses entities, attributes, and
relationships.
• Use: Helpful for communication between designers and end users.
2. Logical Data Models
Now, once the blueprint is ready, the engineer comes in to decide technical details—like
which materials will be used and how things will be structured. Logical data models explain
how data will be structured logically inside the system.
• Example: Relational Model (tables of rows and columns), Hierarchical Model (tree-
like), Network Model (graph-like).
• Use: Bridges the gap between human understanding and machine storage.
3. Physical Data Models
Finally, the workers on the construction site get to work. They decide how bricks are laid,
how wiring is done, and how plumbing fits in. In the database world, physical models deal
with how data is actually stored in memory—indexes, partitions, and file organization.
• Example: Decisions like “store this table on SSD”, “create an index for fast
searching.”
• Use: For performance tuning and physical implementation.
Summary of Types of Data Models
• Conceptual Model → High-level, like a sketch.
• Logical Model → Structured, like a technical plan.
• Physical Model → Implementation, like actual construction.
Now that we understand the broad categories, let’s dive into the logical data models in
detail, because that’s where Hierarchical and Network Models come in.
Easy2Siksha.com
The Hierarchical Model – The Family Tree of Data
Let’s imagine you are in a royal family where there’s a king at the top, then princes, then
their children, and so on. This strict parent-child structure is exactly how the Hierarchical
Model works.
• Data is organized in a tree-like structure.
• Each parent can have multiple children, but each child has only one parent.
• Relationships are one-to-many.
Example: Think of a company database.
• CEO → Managers → Employees.
If you want to see all employees under a manager, it’s easy because the path is
already defined.
Advantages:
• Very fast when you know the exact path.
• Clear and predictable structure.
Disadvantages:
• Rigid. If you want to add a new relationship (like an employee working under two
managers), it becomes messy.
• Difficult to reorganize data.
The Network Model – The Web of Relationships
Now imagine a spider web. Here, one person (or data item) can be linked to many others in
multiple ways. Unlike the strict family tree, the Network Model allows many-to-many
relationships.
• Data is organized as records and sets.
• Each record can have multiple parent and child relationships.
• It uses pointers (links) to connect data items.
Example: Think of a university database.
• A Student can enroll in many Courses.
• A Course can have many Students.
• A Professor can teach many Courses, and each Course can have multiple Professors.
This kind of complexity is easily handled by the Network Model.
Advantages:
Easy2Siksha.com
• Flexible, allows complex relationships.
• Efficient for many-to-many relationships.
Disadvantages:
• Difficult to design and maintain.
• Requires a programmer’s knowledge to navigate links.
Hierarchical Model vs Network Model – The Big Difference
Now, let’s put both models side by side so it’s crystal clear.
Feature
Hierarchical Model
Network Model
Structure
Tree-like (parent-child)
Graph-like (web of nodes and links)
Relationships
One-to-Many
Many-to-Many
Flexibility
Rigid (child has only one parent)
Flexible (child can have multiple
parents)
Navigation
Easy if path is known
More complex, needs pointers
Example Use
Banking system (accounts under a
branch)
University system (students, courses,
professors)
Disadvantage
Hard to reorganize
Hard to design and maintain
A Real-Life Analogy
• Hierarchical Model is like a royal family tree. You clearly know who belongs to
whom, but the relationships are limited.
• Network Model is like a social network. You can be friends with multiple people,
join groups, and connect in multiple ways—it’s flexible but harder to map neatly.
Why Does This Matter?
Understanding these models is not just about passing an exam—it’s about appreciating how
data is organized in real life. For example:
• Banking systems once relied heavily on the Hierarchical Model.
• Airline reservation systems and university databases leaned on the Network Model.
• Later, with time, the Relational Model (tables) became more popular because it
combined simplicity with power.
Easy2Siksha.com
But these older models still laid the foundation of modern database systems.
Final Wrap-Up
So, to summarize in story form:
A database is like a magical library that can tell stories in different styles. The Conceptual
Models are like sketches, the Logical Models are like technical plans, and the Physical
Models are the actual building blocks.
Among logical models, the Hierarchical Model is like a strict family tree—clear but rigid—
while the Network Model is like a spider web or social network—flexible but complex.
Both models were milestones in the journey of database systems, shaping the way we store
and retrieve information today.
2. Explain the following concepts giving suitable example of E-R Diagram:
(a)Strong Enty.
(b)Weak Enty
(c) Relaonships
(d) Specializaon
(c) (Generalizaon.
Ans: A Story-Like Journey Through E-R Diagrams
Have you ever noticed how we humans love telling stories? Whether it’s about kings and
queens, superheroes, or even daily life, stories are the easiest way to understand complex
things.
Now imagine you are sitting in a classroom, and your professor suddenly asks you:
“Explain Strong Entity, Weak Entity, Relationships, Specialization, and Generalization with an
E-R Diagram.”
Most students would panic, thinking — Oh no, this is database stuff, too technical!
But let me tell you a secret. The world of E-R diagrams (Entity-Relationship diagrams) is
nothing but a beautiful story about people, things, and the bonds between them. Once you
see it as a story, it will never feel difficult again.
Easy2Siksha.com
So, let’s begin this journey into the E-R world step by step.
1. What is an E-R Diagram?
Before we jump into entities and relationships, let’s first understand what an E-R Diagram
actually is.
Think of it as a map of the real world. Just like a map shows cities, rivers, and roads
connecting them, an E-R diagram shows:
• Entities → the main characters (like people, objects, or concepts).
• Attributes → the features or qualities of those characters.
• Relationships → the bonds or connections between characters.
For example:
If we are drawing a diagram of a university, we might have:
• Entities like Student, Course, Professor.
• Attributes like Name, Roll Number, Subject.
• Relationships like “enrolls in” (Student → Course), or “teaches” (Professor →
Course).
So, the E-R diagram is basically the storyboard of a database.
Now that the stage is set, let’s dive into the main concepts one by one with stories,
examples, and diagrams.
2(a). Strong Entity
Definition in Simple Words:
A Strong Entity is like the main hero of a movie who can stand alone.
It doesn’t need anyone else to define its existence.
In database terms:
• A strong entity has its own primary key (a unique identifier).
• It can exist independently without depending on another entity.
Easy2Siksha.com
Example Story:
Imagine a University Database.
We have a Student entity.
Each student has a:
• Roll Number (unique)
• Name
• Age
• Course
Here, Student is a strong entity because:
• It has a unique roll number as a primary key.
• It can exist even if no other entity exists.
If you look at the database tomorrow, you can still identify each student by their Roll
Number.
E-R Diagram Example:
+-------------------+
| STUDENT |
+-------------------+
| Roll No (PK) |
| Name |
| Age |
| Course |
+-------------------+
Here, Roll No is the primary key → which makes it strong.
Summary:
A Strong Entity = Independent, self-sufficient, has its own identity (primary key).
Think of it as the main character in a story who doesn’t need anyone else to prove who they
are.
2(b). Weak Entity
Easy2Siksha.com
Definition in Simple Words:
A Weak Entity is like a side character who cannot survive without the hero.
In database terms:
• A weak entity does not have its own primary key.
• It depends on a strong entity for identification.
• It uses something called a partial key along with the strong entity’s key.
Example Story:
Let’s continue with the University Database.
We have a Student (strong entity).
Now, every student may have a Fee Payment Record.
• The payment itself does not have a unique ID.
• To identify it, we need both:
o The Student Roll Number (from Student).
o The Payment Date (as a partial key).
So, Fee Payment is a weak entity because it cannot exist without the Student.
E-R Diagram Example:
Here:
• Student is the strong entity.
• Fee Payment is the weak entity.
• Together, (Roll No + Payment Date) becomes the identifier.
Easy2Siksha.com
Summary:
A Weak Entity = Cannot exist alone, depends on another strong entity.
It’s like a shadow character who only makes sense when the main hero exists.
2(c). Relationships
Definition in Simple Words:
Relationships are like the bonds or connections between characters in a story.
In E-R diagrams, relationships show how two or more entities are linked.
Example Story:
Back to our University Database.
• A Student can enroll in a Course.
• A Professor can teach a Course.
These are relationships because they describe how one entity is connected to another.
Types of Relationships:
1. One-to-One (1:1)
o One student has one unique ID card.
o Example: STUDENT → ID_CARD.
2. One-to-Many (1:M)
o One professor can teach many courses.
o Example: PROFESSOR → COURSE.
3. Many-to-Many (M:N)
o Many students can enroll in many courses.
o Example: STUDENT ↔ COURSE.
E-R Diagram Example:
[STUDENT] ---enrolls---> [COURSE]
[PROFESSOR] ---teaches--> [COURSE]
Easy2Siksha.com
Summary:
Relationships = the glue that connects different entities.
Just like in a family tree, relationships tell us who belongs to whom.
2(d). Specialization
Definition in Simple Words:
Specialization is like saying:
“This hero has special powers.”
It is the process of dividing a big entity into smaller sub-entities based on their unique
features.
Example Story:
In a Hospital Database, we have a Doctor entity.
Now, not all doctors are the same.
• Some are Surgeons.
• Some are Physicians.
• Some are Dentists.
Here, Doctor is the general entity.
Specialization divides it into sub-entities with extra attributes.
• Surgeon → has attribute “Surgery Type”.
• Physician → has attribute “Special Medicine”.
E-R Diagram Example:
[DOCTOR]
|
------------------------------
| | |
[SURGEON] [PHYSICIAN] [DENTIST]
Easy2Siksha.com
Summary:
Specialization = breaking down a big entity into smaller, specialized roles.
It’s like in Marvel movies → all Avengers are heroes, but each has special powers.
2(e). Generalization
Definition in Simple Words:
Generalization is the reverse of specialization.
It’s like saying:
“These different heroes are all part of one bigger group.”
Example Story:
In a Bank Database, we have:
• Saving Account
• Current Account
Instead of treating them separately, we generalize them into one bigger entity: Account.
So, both Saving and Current inherit from Account.
E-R Diagram Example:
[SAVING ACCOUNT] [CURRENT ACCOUNT]
\ /
\ /
[ ACCOUNT ]
Summary:
Generalization = combining smaller entities into one generalized entity.
It’s like saying: “Dogs, Cats, and Horses are all Animals.”
Putting It All Together
Easy2Siksha.com
Now let’s combine everything into one big story:
Imagine you are building a University Database.
• Strong Entities: Student, Professor, Course.
• Weak Entities: Fee Payment (depends on Student).
• Relationships:
o Student enrolls in Course.
o Professor teaches Course.
• Specialization: Professor → Full-Time Professor, Guest Professor.
• Generalization: Library Account + Hostel Account → Student Account.
This creates a complete, logical picture of how the university works.
Exam-Friendly Narrative Style Conclusion
To sum up in a beautiful way:
An E-R diagram is not just a boring database drawing; it is a story of life, characters, and
their bonds.
• Strong Entities are the independent heroes of our story.
• Weak Entities are the side characters who rely on the hero.
• Relationships are the threads of love, duty, and responsibility that connect them.
• Specialization is when our heroes gain special powers and unique roles.
• Generalization is when we realize that, deep down, all these heroes belong to one
big family.
So next time you see an E-R diagram, don’t just think of rectangles and diamonds.
Think of it as a storyboard where each box is a character and each line is their relationship.
That’s the magic of E-R diagrams — turning reality into data, and data into a story.
Easy2Siksha.com
SECTION-B
3. Explain Normalizaon Explain the concept of mul-valued dependency with an
example. How would you remove it to achieve 4NF?
Ans: The Story of Data and Its Journey Toward Perfection
Imagine you are in charge of organizing a giant college festival. Students are registering for
events, teachers are preparing schedules, sponsors are sending funds, and stalls are being
set up. Now, all this information is being written into a single notebook.
At first, everything looks fine—you have all the details in one place. But soon, problems
begin:
• The notebook becomes very bulky.
• When a sponsor changes their phone number, you must update it in multiple pages.
• Sometimes you accidentally write two different spellings of the same student’s
name.
• And when someone asks for a clean list of “all sponsors only,” you waste hours
flipping through mixed data.
This, my friend, is exactly the kind of problem databases face before normalization.
So, just like we clean and arrange our cupboard during Diwali to make it more efficient, we
also “clean” and “arrange” databases so that they work faster, avoid confusion, and prevent
unnecessary repetition. This process is called Normalization.
Step 1: What is Normalization?
Normalization is like teaching your database good manners.
The aim is simple:
• Store data systematically.
• Remove redundancy (no duplicate or repeated data).
• Make sure changes in one place don’t cause problems elsewhere.
• Keep things flexible so that queries and reports are easy.
In technical terms, Normalization is the process of breaking a large, unorganized table into
smaller, logical tables, and then linking them using keys.
Think of it as dividing your festival notebook into:
• One register for students,
Easy2Siksha.com
• One register for events,
• One register for sponsors.
Each register is neat, and whenever you need to know “which student is in which event,”
you simply link them using IDs.
Step 2: The Levels of Normalization (The Ladder of Cleanliness)
To make data fully organized, we move step by step through different Normal Forms. Each
one solves a different problem. Let’s keep it short and sweet:
1. 1NF (First Normal Form):
o No repeating groups of columns.
o Every column should have atomic (indivisible) values.
2. 2NF (Second Normal Form):
o Already in 1NF.
o Remove partial dependency (no attribute should depend on only a part of a
composite key).
3. 3NF (Third Normal Form):
o Already in 2NF.
o Remove transitive dependency (no attribute should depend on another non-
key attribute).
4. BCNF (Boyce-Codd Normal Form):
o A stronger version of 3NF.
5. 4NF (Fourth Normal Form):
o The stage where we deal with multivalued dependencies (our main hero
today).
6. 5NF and beyond:
o Even more specialized, but for our question, 4NF is the destination.
Step 3: What is a Multivalued Dependency? (The Festival Analogy)
Here comes the twist in our story. Imagine you are storing data in the following table for
your college festival:
Student
Event
Hobby
Ramesh
Singing
Painting
Ramesh
Dancing
Painting
Ramesh
Singing
Chess
Ramesh
Dancing
Chess
At first glance, it looks fine. But if you notice carefully, you’ll see a problem:
Easy2Siksha.com
• Ramesh participates in two events: Singing, Dancing.
• Ramesh has two hobbies: Painting, Chess.
• To combine them, we end up repeating every possible pair of event × hobby.
This is called a multivalued dependency (MVD).
In simple words:
A multivalued dependency exists when two columns are independent of each other but
both depend on the same primary key.
Here,
• “Events” are independent of “Hobbies.”
• Both are linked only through the student “Ramesh.”
• But storing them together forces us to repeat data unnecessarily.
So, MVD = data duplication without reason.
Step 4: Why is Multivalued Dependency Bad?
Let’s continue the story:
1. Data Explosion:
If a student has 5 hobbies and joins 4 events, the table will have 5 × 4 = 20 rows for
just one student! Imagine hundreds of students—it will explode.
2. Update Problems:
If Ramesh adds a new hobby, you must add it in multiple rows for each event.
3. Deletion Problems:
If you remove one hobby, you might accidentally remove the record of an event too.
4. Confusion:
It mixes unrelated things (events and hobbies), making the database messy.
This is why database designers said: “We must get rid of these multivalued dependencies.”
And thus came Fourth Normal Form (4NF).
Step 5: Achieving 4NF (Breaking the Table into Neat Pieces)
The solution is simple:
• Separate independent multi-valued facts into different tables.
Let’s fix Ramesh’s table.
Easy2Siksha.com
Wrong (with MVD):
Student
Event
Hobby
Ramesh
Singing
Painting
Ramesh
Dancing
Chess
Correct (after 4NF):
Table 1: Student–Event
Student
Event
Ramesh
Singing
Ramesh
Dancing
Table 2: Student–Hobby
Student
Hobby
Ramesh
Painting
Ramesh
Chess
Now, both tables are neat, no unnecessary repetition, and still fully represent the same
information.
This is exactly how we remove multivalued dependency and achieve Fourth Normal
Form (4NF).
Step 6: A Real-Life Analogy for Easier Understanding
Think about a shopping mall:
• A shopkeeper keeps lists of customers.
• Each customer can buy multiple products.
• Each customer can also have multiple delivery addresses.
If he tries to keep both “Products” and “Addresses” in the same table, he will have to write
every possible combination:
| Customer | Product | Address |
That means for 3 products and 3 addresses, 9 rows will be written. Wasteful!
Instead, the smart way (4NF) is to keep two separate tables:
Easy2Siksha.com
• Customer–Product
• Customer–Address
Much cleaner, faster, and safer.
Step 7: Why Examiners Love This Topic
Whenever you answer such questions, the examiner looks for:
1. A clear definition of Normalization.
2. Step-by-step explanation of multivalued dependency.
3. A good example with a table.
4. Showing how to remove it to achieve 4NF.
5. Bonus points for storytelling or analogy that makes the answer enjoyable.
And now, you have all of them in this answer.
Final Summary
• Normalization = Cleaning and organizing your database.
• Multivalued Dependency = When two independent sets of data depend on the same
key, forcing unnecessary duplication.
• Problem = Redundancy, update issues, confusion.
• Solution (4NF) = Split into separate tables for each independent multivalued fact.
So, just like we divide our cupboard into sections for clothes, books, and shoes, we divide
our database into logical tables—keeping everything neat, accessible, and duplication-free.
That’s the beauty of Normalization and 4NF.
4(a) Explain the signicance of the DBTG report in the development of database
management systems
(b) Describe the principle of least privilege and its importance in database security.
Ans: When you think about how human beings started organizing things, it often began with
something very simple. Long before computers, people wrote records in notebooks, stored
files in cupboards, and organized everything with labels. But as the world grew busier and
information exploded, these traditional ways of storing data became messy, confusing, and
hard to manage. Imagine a huge library where books are just piled in a heap—without
categories, without indexes, and without any system. How would anyone ever find the right
book?
Easy2Siksha.com
This very problem of organization and structure is what gave birth to database
management systems (DBMS). And in the early years of computer science, one small
group’s effort played a groundbreaking role—the DBTG Report. On the other side, as
databases became powerful, a new question appeared: how do we protect this treasure of
data from misuse? That’s where the principle of least privilege comes in. Let’s dive into
both of these ideas, but not like a boring textbook—let’s imagine them as parts of a story of
invention and protection.
(a) The Significance of the DBTG Report
The Early Confusion
In the 1960s, computers had already started to enter organizations, but the way they
handled data was very rigid. Companies stored data in files, and programmers had to write
long, complicated code just to access a single record. Worse, every application was tied
tightly to the way the data was stored. If you changed the data format even slightly, all the
programs broke down!
Imagine if you had to rebuild your entire kitchen every time you bought a new utensil—
frustrating, right? That’s how companies felt about data in those days.
The Call for a Standard
To solve this growing mess, the Conference on Data Systems Languages (CODASYL) formed
a special task group called the Database Task Group (DBTG). Their mission was simple but
ambitious: “Can we design a universal way to describe, store, and access data so that
everyone can follow the same rules?”
In 1971, after years of effort, the DBTG published a report that changed the future of
databases.
What Did the DBTG Report Do?
Think of the DBTG report as the first rulebook for how modern databases should look and
work. Here are its key contributions explained with simple metaphors:
1. Data Model (Network Model):
o The DBTG introduced the network data model, where data was arranged not
just in simple tables or files but as records connected by links.
o Imagine a city map where every house (record) is connected by roads
(pointers). This made it easier to navigate complex relationships.
2. Schemas and Subschemas:
o For the first time, the report clearly separated how data is stored from how
users view it.
o A schema was like the master blueprint of a building, showing the entire
structure.
Easy2Siksha.com
o A subschema was like a personalized floor plan—showing only the parts that
a particular tenant needed.
o This idea allowed different users to see the same data in different ways
without disturbing one another.
3. Data Independence:
o Before the report, changing the way data was stored meant rewriting all
programs. The DBTG’s idea of separating schema from programs gave birth
to data independence—a freedom that made databases flexible and easier
to maintain.
4. Standardization:
o Perhaps the most important gift of the report was that it introduced
standards. Everyone could now speak the same “language of databases.” This
prevented chaos and encouraged further research.
Why Was It So Significant?
The DBTG report might feel old today, but its impact is eternal. It was the seed from which
modern relational databases, object-oriented databases, and even today’s cloud data
platforms grew. Without it, each company might still be creating its own confusing system
of storing information.
So, in simple words, the DBTG report was like the first constitution of the database world—
it didn’t solve every problem, but it laid down principles and rules that guided everything
that came afterward.
(b) The Principle of Least Privilege in Database Security
The Treasure Chest of Data
Now that databases became well-organized, another challenge emerged: how do we
protect this data?
Think of a database as a giant treasure chest filled with gold coins, jewels, and confidential
letters. If everyone in a kingdom is allowed to take the keys and roam freely inside, disaster
will strike. Someone might steal a jewel, some might read secret letters, and others may
accidentally knock over the coins.
This is exactly the situation organizations face today. Data is precious, and not everyone
should have access to everything. That’s where the principle of least privilege (POLP) comes
in.
What Does “Least Privilege” Mean?
The principle of least privilege is very straightforward:
Easy2Siksha.com
• Every user, program, or process should only have the minimum level of access they
absolutely need to perform their job—and nothing more.
For example:
• A cashier in a bank should be able to update account transactions but should not be
able to see the manager’s confidential salary details.
• A student using a library database should be able to search for books but should not
be able to delete records from the system.
Why Is It Important?
1. Minimizes Damage from Mistakes:
o If someone accidentally clicks the wrong button, limited access ensures they
cannot destroy the whole system.
2. Protects Against Insider Threats:
o Sadly, not all dangers come from hackers outside. Sometimes, insiders misuse
their access. Least privilege limits their power.
3. Defends Against Cyberattacks:
o If a hacker steals the password of a low-level user, they can only cause small
harm rather than taking over the entire database.
4. Builds Trust and Compliance:
o Today, laws like GDPR (Europe) and HIPAA (USA) require strict data
protection. Least privilege is a practical way to meet these standards and
build trust.
Real-Life Example
Think of an airport. Not everyone can enter the cockpit of an airplane.
• Passengers only get access to the seating area.
• Crew members access the cabin.
• Only trained pilots can touch the cockpit controls.
If everyone had “full access,” flights would never be safe. Similarly, least privilege
makes sure databases run smoothly without chaos.
Bringing It All Together
The story of databases is really the story of two needs: order and safety.
• The DBTG report gave us order—it created rules and models that allowed data to be
structured, independent, and standardized. Without it, today’s advanced databases
wouldn’t exist.
• The principle of least privilege gave us safety—it reminded us that data, like
treasure, must be guarded carefully, giving access only to those who truly need it.
Easy2Siksha.com
Together, these two ideas form the foundation of modern database management. One
ensured that databases grew logically; the other ensured they grew securely.
So, if you ever walk into a library that is neatly arranged and carefully monitored,
remember—you are witnessing the spirit of the DBTG report and the principle of least
privilege at work.
SECTIONC
5. (a) Explain the concept of DCL. Explain the use of DCL. statements using suitable
examples.
(b) Explain the use of Union, Intersecon and Minus funcon using suitable example.
Ans: Part (a): The Story of DCL – Data Control Language
Imagine you are the manager of a giant library. This library isn’t full of storybooks—it’s full
of information about thousands of people, employees, products, and so on. Just like any
library, you can’t allow everyone to walk into the restricted section and touch the rare,
valuable books. Some staff are allowed in, some aren’t. Some can only read, while others
can also borrow.
In the world of databases, the same rule applies. You cannot let everyone have the same
rights. Some users should only be able to see data, others may be allowed to change data,
and some may even have the power to control the database itself.
This is where DCL (Data Control Language) enters the picture.
What is DCL?
DCL is like the “security guard” or “permission controller” of the database. It consists of
special SQL commands that deal with who is allowed to do what inside the database.
Think of DCL as the keys to the library rooms.
• Some people get the key to open only the reading room.
• Some people get the key to both the reading room and the store room.
• And the head librarian (administrator) has the master key to every single section.
DCL ensures that only the right people have the right keys.
Easy2Siksha.com
Main DCL Commands
There are mainly two DCL commands you should remember:
1. GRANT → This is like giving someone the key (permission).
2. REVOKE → This is like taking the key back.
Let’s see them in action.
Example of GRANT
Suppose we have a database for a company called TechWorld. Inside this company
database, there is an Employee table which stores information like employee names,
salaries, and job positions.
Now, you are the Database Admin (DBA). A new HR intern joins, and she needs to check
employees’ names and job positions, but she should not see salaries (because that’s
sensitive information).
So, what do you do? You use the GRANT command:
GRANT SELECT ON Employee TO HR_Intern;
This means: “Dear HR Intern, I am giving you the key to only read data from the Employee
table. You cannot change anything, you cannot delete, you cannot update—just read.”
Simple, right? Just like letting the intern into the reading room but not the store room.
Example of REVOKE
Now imagine, after a few months, the HR intern leaves the company. Should she still have
the key? Of course not! That could be dangerous.
So, you take back the permission using REVOKE:
REVOKE SELECT ON Employee FROM HR_Intern;
This means: “Sorry, intern, your access is gone now.”
Why is DCL Important?
DCL isn’t just about giving and taking permissions. It’s about:
Easy2Siksha.com
• Security → Preventing unauthorized access (like protecting secret recipes in a
restaurant database).
• Control → Managing who can update or delete critical data.
• Privacy → Restricting sensitive information (like salaries, patient records, exam
marks).
• Order → Avoiding chaos when multiple users work together.
Imagine if everyone in a bank database could update balances! Total disaster. DCL prevents
this chaos.
Other Points About DCL
• DCL works hand-in-hand with DDL (Data Definition Language) and DML (Data
Manipulation Language). DDL creates the structure, DML changes the data, and DCL
decides who can use what.
• Sometimes DCL commands like GRANT also include specific privileges such as:
o SELECT (read data)
o INSERT (add new data)
o UPDATE (change data)
o DELETE (remove data)
For example:
GRANT SELECT, INSERT ON Employee TO Manager;
This means: The Manager can read and add employee records but cannot delete them.
In short:
DCL is like the permission slip system of the database. It ensures that the right people have
the right level of access at the right time. It’s not about handling data itself—it’s about
controlling the power over data.
Part (b): UNION, INTERSECTION, and MINUS – The Magical Set Operations
Now, let’s move to the second part. This is where SQL feels like a game of mixing and
matching sets, very similar to Venn diagrams we learned in school.
To make this fun, imagine two college classrooms: Class A and Class B. Each has a list of
students who are good at different activities. We’ll use these classes to understand UNION,
INTERSECTION, and MINUS.
Easy2Siksha.com
1. UNION – Bringing Everyone Together
Suppose Class A has these students who play cricket:
{Rahul, Neha, Arjun}
And Class B has these students who play cricket:
{Arjun, Meena, Sameer}
Now, if I ask: “Give me a list of all unique students from both classes who play cricket,” what
will you do? You’ll combine both groups, but without repeating anyone.
So the result will be:
{Rahul, Neha, Arjun, Meena, Sameer}
This is exactly what UNION does in SQL.
SQL Example:
SELECT student_name FROM ClassA_Cricket
UNION
SELECT student_name FROM ClassB_Cricket;
Result: All students from both classes who play cricket (duplicates removed automatically).
Important Note: UNION always removes duplicates unless you specifically use UNION
ALL.
• UNION → Unique values only.
• UNION ALL → Keeps duplicates as well.
2. INTERSECTION – Common Ground
Now let’s ask: “Who are the students who play cricket in both Class A and Class B?”
Look at the sets:
• Class A: {Rahul, Neha, Arjun}
• Class B: {Arjun, Meena, Sameer}
Who appears in both? → {Arjun}
This is INTERSECTION.
Easy2Siksha.com
SQL Example:
SELECT student_name FROM ClassA_Cricket
INTERSECT
SELECT student_name FROM ClassB_Cricket;
Result: {Arjun}
In real life: Intersection is very useful when you want to find common customers,
common employees, common subscribers, etc.
For example, “Which customers bought from both the online store and the physical store?”
3. MINUS – Finding the Difference
Now let’s ask: “Who are the students who play cricket in Class A but not in Class B?”
• Class A: {Rahul, Neha, Arjun}
• Class B: {Arjun, Meena, Sameer}
Result → {Rahul, Neha} (because Arjun is in both, so he’s removed).
This is MINUS.
SQL Example:
SELECT student_name FROM ClassA_Cricket
MINUS
SELECT student_name FROM ClassB_Cricket;
Result: {Rahul, Neha}
Real-life example:
Imagine two mailing lists:
• One for free subscribers.
• One for paid subscribers.
Easy2Siksha.com
If you want to know who is only in free list but not in paid list, you use MINUS.
Comparison Table
Operation
What It Does
Example Result (Class A vs Class B)
UNION
Combines both sets (removes duplicates)
{Rahul, Neha, Arjun, Meena, Sameer}
INTERSECT
Finds common elements
{Arjun}
MINUS
Finds elements in one set but not the other
{Rahul, Neha}
A Fun Analogy
Think of two friend groups planning a picnic.
• UNION: All friends from both groups are invited.
• INTERSECT: Only mutual friends are invited.
• MINUS: Friends who are in one group but not the other.
This is how SQL set operators work in a fun, everyday scenario.
Bringing It All Together
Now, let’s tie both parts of the question together.
1. DCL (GRANT, REVOKE) ensures that only the right people can query, insert, update,
or delete data. It’s about who gets the keys.
2. Set Operators (UNION, INTERSECT, MINUS) help us play with results from different
queries, just like joining or comparing groups of students, customers, or records.
Both are different sides of SQL—
• DCL is about permissions and security.
• Set operations are about data combination and analysis.
Easy2Siksha.com
6. What is a cursor in a database, and why is it used How would you use the % FOUND,
%NOTFOUND. %ROWCOUNT, and %ISOPEN aributes in a SQL block?
Ans: A Story about Cursors in Databases
Imagine you are in a giant library. This library has thousands of books neatly stored on the
shelves, just like rows of data inside a database table. Now, let’s say you’re asked to read
one book at a time, check some details, maybe take notes, and then move on to the next.
Would you grab the entire shelf of books at once? Probably not—it would be messy,
confusing, and you might drop everything on the floor. Instead, you’d pick one book at a
time, read it, decide what to do with it, and then move on.
This is exactly what happens inside a database. When you query a table with thousands of
rows, the database doesn’t always dump all rows into your hands at once. Instead, it gives
you a special tool called a cursor.
What is a Cursor?
A cursor in a database is like a bookmark or pointer that allows you to go through rows of a
query result one at a time.
Think of it as a helping hand when you want to handle records individually instead of all
together.
• Without a cursor: You can only deal with bulk sets of data (like fetching all rows at
once).
• With a cursor: You can pick one row, process it, then move to the next, and so on.
In simple words: A cursor is a pointer that travels over the rows of a query result, one row
at a time.
Why Do We Use Cursors?
Let’s return to our library story. Suppose you are given a task:
• “For every book in the library, if the author is Shakespeare, put it in the ‘Classics’
box. If the author is Rowling, put it in the ‘Fantasy’ box.”
You can’t make this decision without looking at each book individually.
Similarly, in databases, sometimes you want to process records one by one—for example:
• Calculating salaries for employees one at a time.
Easy2Siksha.com
• Sending personalized emails to customers.
• Applying conditional logic depending on the value in each row.
For these cases, a cursor is your best friend.
Attributes of a Cursor
Now that you know why cursors exist, let’s talk about the little status checkers that come
along with them. These are called cursor attributes, and they help you know what’s going
on while you are working with the cursor.
Think of them like the little sticky notes you place while reading books:
1. %FOUND
o This tells you: “Did I find a row to work with?”
o If the cursor has just fetched a row successfully, %FOUND becomes TRUE.
o Example: You just opened a book—it exists—so %FOUND = TRUE.
2. %NOTFOUND
o This is the opposite of %FOUND.
o It tells you: “Did I fail to find a row?”
o If there are no more rows left to fetch, %NOTFOUND becomes TRUE.
o Example: You reached the end of the shelf—no more books—so
%NOTFOUND = TRUE.
3. %ROWCOUNT
o This one is like your personal counter: “How many rows have I processed so
far?”
o Each time you fetch a row, the counter goes up by 1.
o Example: You’ve already checked 5 books, so %ROWCOUNT = 5.
4. %ISOPEN
o This attribute tells you whether the cursor is still open or closed.
o %ISOPEN = TRUE if the cursor is active and ready for use.
o %ISOPEN = FALSE if you’ve closed it or never opened it.
o Example: Did you still leave the library open? Or did you lock the door?
Using Cursors and Their Attributes in SQL Blocks
Now let’s see how we can actually use these ideas inside a SQL block (like PL/SQL in Oracle).
Imagine you have an Employees table with columns: emp_id, name, salary. Your task is to
give a 10% raise to employees earning less than 30,000.
Here’s how you would use a cursor step by step:
1. Declare the cursor (like planning which shelf of the library you want to check):
Easy2Siksha.com
CURSOR emp_cursor IS
SELECT emp_id, name, salary
FROM employees;
2. Open the cursor (like opening the shelf and starting to look at books):
OPEN emp_cursor;
3. Fetch rows one by one (like picking one book at a time):
FETCH emp_cursor INTO v_id, v_name, v_salary;
4. Check attributes while working:
WHILE emp_cursor%FOUND LOOP
IF v_salary < 30000 THEN
UPDATE employees SET salary = salary * 1.1
WHERE emp_id = v_id;
END IF;
FETCH emp_cursor INTO v_id, v_name, v_salary;
END LOOP;
5. Close the cursor (like shutting the shelf after you’re done):
CLOSE emp_cursor;
How the Attributes Work in This Story
• When the first FETCH succeeds, %FOUND = TRUE, %NOTFOUND = FALSE.
• If we reach the end of the table, %FOUND = FALSE, %NOTFOUND = TRUE.
• %ROWCOUNT keeps telling us how many employees we’ve already processed.
• %ISOPEN can be checked before closing, to make sure the cursor is still active.
Putting It Together in a Fun Way
Think of it like this:
• %FOUND is the Yes/No flag when you ask: “Did I find the next row?”
• %NOTFOUND is the end signal saying: “No more rows left.”
• %ROWCOUNT is your progress tracker saying: “I’ve done X rows so far.”
• %ISOPEN is your door check saying: “Is the cursor door open or closed?”
Why Examiners Like This Question
Easy2Siksha.com
This question is not just about syntax—it’s about thinking logically. Examiners want to see if
you understand:
• Why cursors exist (processing rows one at a time).
• What each attribute means in practical terms.
• How to write a SQL block with cursor handling.
If you explain it like a story, it shows not only that you know the technical part but also that
you truly understand the concept.
Conclusion
A cursor in a database is like a bookmark in a library that lets you go row by row instead of
carrying the whole shelf. Its attributes—%FOUND, %NOTFOUND, %ROWCOUNT, and
%ISOPEN—are like guides and trackers that help you safely and effectively process each
record.
So next time you hear about cursors, just imagine yourself walking through a big library,
picking books one by one, checking them carefully, and keeping sticky notes of what you’ve
done. That’s the magic of cursors in databases!
SECTION-D
7. How does big data dier from tradional data processing systems? Write some popular
tools used in big data analycs. Provide examples of how big data analycs is 1 used in
dierent industries.
Ans: Imagine you walk into a small village library. The library has just a few hundred books,
neatly arranged on shelves. If you want a book, the librarian can easily find it for you by
checking her small register. Everything runs smoothly because the amount of data (books) is
small.
Now, fast forward to a city like New York, where the library has millions of books,
magazines, newspapers, and even digital copies. The old system of a single register simply
cannot handle it anymore. You’ll need computers, advanced search systems, barcodes,
cloud storage, and even Artificial Intelligence to quickly find, store, and analyze the massive
information.
This difference between the village library (small data handled traditionally) and the city
library (huge, complex data handled with advanced tools) is exactly how Big Data differs
from Traditional Data Processing Systems.
Easy2Siksha.com
Let’s now dive deeper into the concept, just like unwrapping a story one chapter at a time.
1. What is Traditional Data Processing?
Traditional data processing is like how the village librarian works. Data is small, structured,
and manageable.
• Data usually comes in rows and columns (like Excel sheets or small databases).
• Tools like relational databases (Oracle, MySQL, SQL Server) can easily manage it.
• Storage capacity is limited but sufficient because the volume is not overwhelming.
• Processing is usually batch-oriented (done step by step).
• Examples: Maintaining a shop’s daily sales record, keeping track of employee
salaries, or storing bank account details.
In short: Traditional systems are perfect for small, structured, predictable data.
2. What is Big Data?
Now picture the giant city library. People don’t just want books; they want videos, audio
books, scanned documents, social media reviews, and even real-time updates. This is the
world of Big Data.
Big Data means large, complex, and fast-growing sets of data that traditional systems
cannot handle. It is often described by the famous 3Vs (and later 5Vs):
1. Volume – The size of data is enormous (terabytes, petabytes, and more).
Example: Facebook generates billions of photos and posts daily.
2. Velocity – Data is generated at high speed.
Example: Stock market transactions, WhatsApp messages, live cricket score updates.
3. Variety – Data comes in many formats: text, audio, video, logs, GPS signals, etc.
Example: Tweets, YouTube videos, Google search queries.
4. Veracity – Data can be uncertain or messy.
Example: Fake news on social media mixed with real news.
5. Value – The ultimate goal is to extract useful insights.
Example: Amazon analyzing shopping patterns to recommend products.
In short: Big Data is huge, fast, unstructured, and powerful when analyzed correctly.
3. How Big Data Differs from Traditional Systems
Let’s compare the two worlds clearly:
Easy2Siksha.com
Feature
Traditional Systems
Big Data Systems
Data Size
MBs to GBs
TBs to Petabytes and beyond
Data Type
Structured (tables, rows,
columns)
Structured + Semi-structured +
Unstructured
Processing
Speed
Slower, batch-based
Real-time or near real-time
Storage
Single server or limited database
Distributed storage (Cloud, Hadoop clusters)
Scalability
Limited, costly to scale
Highly scalable, adds servers easily
Tools
SQL, RDBMS
Hadoop, Spark, Hive, Flink, etc.
Traditional systems are like bicycles – perfect for short rides. Big Data systems are like
bullet trains – designed for speed, scale, and massive loads.
4. Popular Tools Used in Big Data Analytics
Just like you need modern machinery to manage the huge city library, Big Data requires
advanced tools. Here are some well-known ones:
• Hadoop – The backbone of Big Data. It stores huge data sets across clusters of
computers.
• Apache Spark – Known for lightning-fast data processing. Often used in real-time
analytics.
• Hive – Works like SQL but for Big Data stored in Hadoop.
• NoSQL Databases (MongoDB, Cassandra) – Handle unstructured data like images,
videos, or JSON files.
• Kafka – Manages real-time data streaming (used by Netflix, Uber).
• Tableau & Power BI – For data visualization (turning numbers into interactive
charts).
These tools act like superheroes in the Big Data world – each with its own special
power.
5. Applications of Big Data in Different Industries
This is where the real magic happens. Big Data is not just theory; it’s shaping our daily lives
across industries. Let’s explore with examples:
Easy2Siksha.com
(a) Healthcare
Doctors and hospitals now use Big Data to save lives.
• Analyzing patient records, X-rays, and genetic data to predict diseases.
• During COVID-19, Big Data was used to track virus spread and vaccine effectiveness.
• Wearables like smartwatches collect real-time heart rate, sleep patterns, and send
alerts.
(b) Retail & E-commerce
Ever wondered how Amazon knows what you want before you search? That’s Big Data.
• Personalized recommendations based on your browsing history.
• Predicting festive season demand (like Diwali sales).
• Dynamic pricing – prices change in real time depending on demand.
(c) Banking & Finance
Banks fight fraud using Big Data.
• Detecting unusual credit card transactions.
• Stock market prediction through real-time analytics.
• Personalized loan offers based on spending patterns.
(d) Transportation & Travel
• Uber uses Big Data to match drivers and passengers in real time.
• Airlines use it for fuel efficiency and predicting delays.
• Google Maps suggests the fastest route by analyzing millions of GPS signals.
(e) Entertainment & Media
• Netflix recommends shows based on your viewing habits.
• YouTube suggests videos using Big Data algorithms.
• Bollywood producers even analyze social media reactions before finalizing scripts.
(f) Government & Smart Cities
• Big Data helps in crime prediction (predictive policing).
• Traffic management through CCTV and sensor analysis.
• Disaster management – predicting floods, earthquakes, and cyclones.
In simple words: Big Data is like a magic lens helping every industry see patterns, make
decisions, and improve lives.
Easy2Siksha.com
6. Conclusion – The Journey from Small Library to Big Universe
So, if we revisit our story:
• Traditional data systems are like the small village library – simple, neat, easy to
manage.
• Big Data is like the giant city library – massive, complex, and impossible to handle
without modern tools.
Big Data analytics has transformed healthcare, banking, e-commerce, travel, and even
governance. With tools like Hadoop, Spark, and Tableau, we can extract valuable insights
from the ocean of data around us.
In today’s world, every click, every swipe, every photo, and every video generates data. The
organizations that can harness this data are the ones that lead the future.
8. What are NoSQL databases? How does NoSQL dier from tradional relaonal
databases? Explain some advantages of NoSQL databases.
Ans: Imagine you live in a big city. In this city, there are two types of libraries where people
store and manage their books.
The first type of library is very strict. Every book must be placed on a shelf in the exact
order: shelf number, row number, column number, and even according to category. If you
want to add a new book, you must first fill out a long form: What’s the title? Author? Genre?
Page count? Year? Only after that will the librarian allow it to be placed neatly in the right
section. This is how Relational Databases (RDBMS) work. They follow fixed rules, strict
structures (called schemas), and make sure everything is perfectly organized like tables in
Excel.
Now, the second type of library is more flexible and modern. It says, “Don’t worry about the
rules! Just bring your book. If you want, give me the author’s name and title, but if you don’t
have it, no problem. We’ll still keep it. You can even bring audio files, comic books, or
handwritten notes. I’ll adjust my shelves to fit whatever you bring.” This is how NoSQL
Databases work. They don’t force you to follow strict rules. They allow freedom, flexibility,
and adaptability for different types of information.
This little story already shows the biggest difference: RDBMS = strict, structured, table-like;
NoSQL = flexible, free, adaptable.
Now let’s carefully explore this question step by step in a clear and human way.
What are NoSQL Databases?
Easy2Siksha.com
The term NoSQL actually stands for “Not Only SQL.” That means it doesn’t completely reject
SQL or relational databases, but it goes beyond them.
In simple words, NoSQL databases are modern databases that store and manage data in
flexible, non-tabular forms. Instead of using only rows and columns like traditional
databases, NoSQL can store data as:
1. Documents (like JSON or XML files) – Imagine keeping your data as a mini file that
contains all related information in one place.
2. Key-Value Pairs – Just like a dictionary where you look up a word (key) to get its
meaning (value).
3. Column-based – Storing data column by column, useful for very large data analytics.
4. Graph-based – Storing relationships, like a social network where people are nodes
and friendships are connections.
So, NoSQL is not one single database type—it is a family of databases that handle data in
different, more flexible ways.
How does NoSQL differ from Traditional Relational Databases?
Let’s continue with our library example but now make a side-by-side comparison.
1. Structure of Data
o Relational Database (RDBMS): Very strict. Data must be stored in tables with
rows and columns. Example: Student records with fixed fields like Roll No,
Name, Address, Marks.
o NoSQL Database: Very flexible. Data can be stored as documents, key-value
pairs, graphs, or columns. Example: A student’s record can include Name and
Marks, but if another student also has details like Instagram Handle or
Favorite Game, that’s fine—NoSQL will allow it.
2. Schema (Rules for Data)
o RDBMS: Schema is fixed. You must define the structure before adding data. If
you want to add a new column later, you must update the whole table.
o NoSQL: Schema-free or dynamic. You can insert data with different fields at
any time without worrying about redesigning the database.
3. Scalability
o RDBMS: Vertical scalability. To handle more data, you must buy a bigger,
more powerful machine (which is costly).
o NoSQL: Horizontal scalability. You can simply add more normal machines
(servers) to the system, like adding more shelves in the library. It’s cheaper
and more practical for huge data.
4. Data Relationships
o RDBMS: Excellent at handling complex relationships using joins between
tables.
Easy2Siksha.com
o NoSQL: Better at handling large amounts of unstructured data, but complex
joins are not its strength (except in graph databases).
5. Use Cases
o RDBMS: Perfect for banking systems, airline bookings, school management—
anywhere data is structured and consistency is important.
o NoSQL: Ideal for social media platforms, e-commerce websites, big data
analytics, IoT, and mobile apps where flexibility and speed matter more than
rigid structure.
Advantages of NoSQL Databases
Now, let’s highlight why NoSQL is becoming so popular in the age of big data and social
networks.
1. Flexibility with Data
o NoSQL does not force you to stick to one structure. You can store text,
images, videos, or logs together. This is very useful for modern apps where
data comes in many shapes.
2. High Scalability
o Just like adding more shelves in the flexible library, you can expand a NoSQL
database by simply adding more servers. This is cost-effective and makes it
suitable for companies like Google, Amazon, and Facebook who deal with
massive data every second.
3. Faster Performance
o Since data is often stored in a way that avoids heavy joins, queries can be
much faster. For example, finding a user’s profile in a document-based
NoSQL database is quick because all details are in one place.
4. Handling Big Data
o NoSQL is designed for big data, where information may be unstructured and
coming at high speed (called velocity). For example, real-time analytics from
millions of devices is better handled with NoSQL.
5. Cost-Effective
o Instead of buying one super-expensive machine, you can use many cheaper
servers. This makes it budget-friendly for startups and large organizations
alike.
6. Better for Cloud and Modern Applications
o Most NoSQL databases are cloud-friendly. They integrate well with web and
mobile apps where user needs keep changing.
Bringing it All Together
Think again about the two libraries:
Easy2Siksha.com
• The old relational library is perfect if you want everything highly structured, neat,
and predictable.
• The new NoSQL library is perfect if you want flexibility, speed, and the ability to
handle any type of data, even if it doesn’t fit into neat rows and columns.
That’s why, in today’s world of social media, e-commerce, cloud apps, and IoT, NoSQL has
become a hero. But at the same time, relational databases are still very important where
strict rules, consistency, and reliability are needed (like banking).
In short:
• NoSQL = flexibility, scalability, big data
• RDBMS = structure, consistency, reliability
Both are valuable, but they serve different purposes.
“This paper has been carefully prepared for educaonal purposes. If you noce any mistakes or
have suggesons, feel free to share your feedback.”
